package com.deductive.common.utils;

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson2.JSONObject;

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 命名风格转换工具类 (驼峰 <-> 下划线)
 */
public class NamingUtils {

    /**
     * 将 Map 的 Key 从下划线转换为驼峰
     * @param map 原始Map
     * @return 转换后的新Map
     */
    public static Map<String, Object> mapToCamelCase(Map<String, Object> map) {
        if (map == null || map.isEmpty()) {
            return map;
        }
        return map.entrySet().stream()
                .collect(Collectors.toMap(
                        entry -> StrUtil.toCamelCase(entry.getKey()),
                        Map.Entry::getValue
                ));
    }

    /**
     * 将 Map 的 Key 从下划线转换为驼峰
     * @param json 原始Map
     * @return 转换后的新Map
     */
    public static JSONObject jsonToCamelCase(JSONObject json) {
        if (json == null || json.isEmpty()) {
            return json;
        }
        JSONObject result = new JSONObject(json.size());
        for (Map.Entry<String, Object> entry : json.entrySet()) {
            String camelCaseKey = StrUtil.toCamelCase(entry.getKey());
            result.put(camelCaseKey, entry.getValue());
        }
        return result;
    }

    /**
     * 将 List<Map> 中所有 Map 的 Key 从下划线转换为驼峰
     * @param list 原始List
     * @return 转换后的新List
     */
    public static List<Map<String, Object>> listToCamelCase(List<Map<String, Object>> list) {
        if (list == null || list.isEmpty()) {
            return list;
        }
        return list.stream()
                .map(NamingUtils::mapToCamelCase)
                .collect(Collectors.toList());
    }

    /**
     * 将 List<Map> 中所有 Map 的 Key 从下划线转换为驼峰
     * @param list 原始List
     * @return 转换后的新List
     */
    public static List<JSONObject> jsonListToCamelCase(List<JSONObject> list) {
        if (list == null || list.isEmpty()) {
            return list;
        }
        return list.stream()
                .map(NamingUtils::jsonToCamelCase)
                .collect(Collectors.toList());
    }

    /**
     * 将 Map 的 Key 从驼峰转换为下划线
     * @param map 原始Map
     * @return 转换后的新Map
     */
    public static Map<String, Object> mapToSnakeCase(Map<String, Object> map) {
        if (map == null || map.isEmpty()) {
            return map;
        }
        return map.entrySet().stream()
                .collect(Collectors.toMap(
                        entry -> StrUtil.toUnderlineCase(entry.getKey()),
                        Map.Entry::getValue
                ));
    }

    /**
     * 将条件列表 (List<Map>) 中的 'field' 字段名从驼峰转换为下划线
     * @param conditions 原始条件列表
     * @return 转换后的新条件列表
     */
    public static List<Map<String, Object>> conditionsToSnakeCase(List<Map<String, Object>> conditions) {
        if (conditions == null || conditions.isEmpty()) {
            return conditions;
        }
        return conditions.stream()
                .map(condition -> {
                    if (condition.containsKey("field")) {
                        condition.put("field", StrUtil.toUnderlineCase((String) condition.get("field")));
                    }
                    return condition;
                })
                .collect(Collectors.toList());
    }

    /**
     * 将条件列表 (List<Map>) 中的 'field' 字段名从驼峰转换为下划线
     *
     * @param conditions 原始条件列表
     * @return 转换后的新条件列表
     */
    public static List<JSONObject> jsonToSnakeCase(List<JSONObject> conditions) {
        if (conditions == null || conditions.isEmpty()) {
            return conditions;
        }
        return conditions.stream()
                .map(condition -> {
                    if (condition.containsKey("field")) {
                        condition.put("field", StrUtil.toUnderlineCase((String) condition.get("field")));
                    }
                    return condition;
                })
                .collect(Collectors.toList());
    }
}

